{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "tf.logging.set_verbosity(tf.logging.INFO)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load mnist image data \n",
    "# training data shape \n",
    "# training data labels\n",
    "# validation images shape \n",
    "# validation labels shape\n",
    "# test images shape\n",
    "# test labels shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-3-637c263db9cc>:1: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From /Users/mac/anaconda3/envs/tensorflow/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From /Users/mac/anaconda3/envs/tensorflow/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From /Users/mac/anaconda3/envs/tensorflow/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./train-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /Users/mac/anaconda3/envs/tensorflow/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.one_hot on tensors.\n",
      "Extracting ./t10k-images-idx3-ubyte.gz\n",
      "Extracting ./t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /Users/mac/anaconda3/envs/tensorflow/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "(55000, 784)\n",
      "(55000, 10)\n",
      "(5000, 784)\n",
      "(5000, 10)\n",
      "(10000, 784)\n",
      "(10000, 10)\n"
     ]
    }
   ],
   "source": [
    "mnist = input_data.read_data_sets(\"./\", one_hot=True)\n",
    "print(mnist.train.images.shape)\n",
    "print(mnist.train.labels.shape)\n",
    "print(mnist.validation.images.shape)\n",
    "print(mnist.validation.labels.shape)\n",
    "print(mnist.test.images.shape)\n",
    "print(mnist.test.labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 可以看到images里面有数量不等的图片，每张图片是28x28长度的一个一维向量，\n",
    "# 所以用的时候需要先给它还原成28x28的二维图片。labels中则是图片对应的数字的值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 8))\n",
    "for idx in range(16):\n",
    "    plt.subplot(4, 4, idx + 1)\n",
    "    plt.axis('off')\n",
    "    plt.title('[{}]'.format(np.argmax(mnist.train.labels[idx])))\n",
    "    plt.imshow(mnist.train.images[idx].reshape((28, 28)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 接下来，定义用于训练的网络，首先定义网络的输入。\n",
    "# 这里我们直接使用上面的数据作为输入，所以定义两个placeholder分别用于图像和lable数据，\n",
    "# 另外，定义一个bool类型的变量用于标识当前网络是否正在训练。\n",
    "# 为了让网络更高效的运行，多个数据会被组织成一个batch送入网络，\n",
    "# 两个placeholder的第一个维度就是batchsize，因为我们这里还没有确定batchsize，所以第一个维度留空。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tf.placeholder(\"float\", [None, 784], name='x')\n",
    "y = tf.placeholder(\"float\", [None, 10], name='y')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 输入的图片是reshape为[-1,28,28,1]的二维图片\n",
    "# 接下来，我们定义第一个卷积层，使用6个5X5的卷积核对输入数据进行卷积， padding方式选择valid，所以输出数据的宽高变为24x24,但是深度已经从原来的1变成了6。 本层卷积的激活函数为relu。\n",
    "# 28 * 28 size: x_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor(\"Reshape_2:0\", shape=(?, 28, 28, 1), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "x_image = tf.reshape(x, [-1, 28, 28, 1])\n",
    "\n",
    "print(x_image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define one conv2d layer\n",
    "# define one conv2d pooling layer: sub_sample for pic to one array\n",
    "# depth not change for size for 12 * 12 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('conv1'):\n",
    "    C1 = tf.contrib.slim.conv2d(\n",
    "        x_image, 6, [5, 5], padding='VALID', activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('pool1'):\n",
    "    S2 = tf.contrib.slim.max_pool2d(C1, [2, 2], stride=[2, 2], padding='VALID')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define second conv2d layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('conv2'):\n",
    "    C2 = tf.contrib.slim.conv2d(\n",
    "        S2, 6, [5, 5], padding='VALID', activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('pool1'):\n",
    "    S3 = tf.contrib.slim.max_pool2d(C2, [2, 2], stride=[2, 2], padding='VALID')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 链接两个全连接层"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 全连接网络: 120 fully_connected layer 120"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('fc1'):\n",
    "    S4_flat = tf.contrib.slim.flatten(S3)\n",
    "    C5 = tf.contrib.slim.fully_connected(S4_flat, 120, activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 全联接网络: 84 fully_connected layer 84"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('fc2'):\n",
    "    F6 = tf.contrib.slim.fully_connected(C5, 84, activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# drop rate: 去避免过拟核\n",
    "###### 对特征添加一个0.6的dropout，以40%的概率丢弃特征中的某些数据，\n",
    "# 这样可以提高网络的推广能力，减少过拟合的可能性。\n",
    "# 需要注意的是，dropout仅在训练的时候使用，验证的时候，需要关闭dropout，\n",
    "# 所以验证时候的keep_prob是1.0。\n",
    "# dropout的输出最终送入一个隐层为10的全连接层，这个全连接层即为最后的分类器。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('dropout'):\n",
    "    keep_prob = tf.placeholder(name='keep_prob', dtype=tf.float32)\n",
    "    F6_drop = tf.nn.dropout(F6, keep_prob)\n",
    "\n",
    "with tf.name_scope('fc3'):\n",
    "    logits = tf.contrib.slim.fully_connected(F6_drop, 10, activation_fn=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 接下来定义loss和用于优化网络的优化器。loss计算使用了sparse_softmax_cross_entropy_with_logits,\n",
    "# 这样做的好处是labels可以不用手动做one_hot省了一些麻烦。这里使用了sgd优化器，学习率为0.3。\n",
    "# 试试看，增大减小学习率，换个优化器再进行训练会发生什么。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-52-3c77ec77605a>:2: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "\n",
      "Future major versions of TensorFlow will allow gradients to flow\n",
      "into the labels input on backprop by default.\n",
      "\n",
      "See @{tf.nn.softmax_cross_entropy_with_logits_v2}.\n",
      "\n",
      "Conv/weights:0\n",
      "INFO:tensorflow:Summary name Conv/weights:0 is illegal; using Conv/weights_0 instead.\n",
      "Conv/biases:0\n",
      "INFO:tensorflow:Summary name Conv/biases:0 is illegal; using Conv/biases_0 instead.\n",
      "Conv_1/weights:0\n",
      "INFO:tensorflow:Summary name Conv_1/weights:0 is illegal; using Conv_1/weights_0 instead.\n",
      "Conv_1/biases:0\n",
      "INFO:tensorflow:Summary name Conv_1/biases:0 is illegal; using Conv_1/biases_0 instead.\n",
      "Conv_2/weights:0\n",
      "INFO:tensorflow:Summary name Conv_2/weights:0 is illegal; using Conv_2/weights_0 instead.\n",
      "Conv_2/biases:0\n",
      "INFO:tensorflow:Summary name Conv_2/biases:0 is illegal; using Conv_2/biases_0 instead.\n",
      "fully_connected/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected/weights:0 is illegal; using fully_connected/weights_0 instead.\n",
      "fully_connected/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected/biases:0 is illegal; using fully_connected/biases_0 instead.\n",
      "fully_connected_1/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_1/weights:0 is illegal; using fully_connected_1/weights_0 instead.\n",
      "fully_connected_1/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_1/biases:0 is illegal; using fully_connected_1/biases_0 instead.\n",
      "fully_connected_2/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_2/weights:0 is illegal; using fully_connected_2/weights_0 instead.\n",
      "fully_connected_2/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_2/biases:0 is illegal; using fully_connected_2/biases_0 instead.\n",
      "fully_connected_3/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_3/weights:0 is illegal; using fully_connected_3/weights_0 instead.\n",
      "fully_connected_3/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_3/biases:0 is illegal; using fully_connected_3/biases_0 instead.\n",
      "fully_connected_4/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_4/weights:0 is illegal; using fully_connected_4/weights_0 instead.\n",
      "fully_connected_4/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_4/biases:0 is illegal; using fully_connected_4/biases_0 instead.\n",
      "fully_connected_5/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_5/weights:0 is illegal; using fully_connected_5/weights_0 instead.\n",
      "fully_connected_5/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_5/biases:0 is illegal; using fully_connected_5/biases_0 instead.\n",
      "fully_connected_6/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_6/weights:0 is illegal; using fully_connected_6/weights_0 instead.\n",
      "fully_connected_6/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_6/biases:0 is illegal; using fully_connected_6/biases_0 instead.\n"
     ]
    }
   ],
   "source": [
    "cross_entropy_loss = tf.reduce_mean(\n",
    "    tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y))\n",
    "\n",
    "l2_loss = tf.add_n([\n",
    "    tf.nn.l2_loss(w)\n",
    "    for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)\n",
    "])\n",
    "\n",
    "for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES):\n",
    "    print(w.name)\n",
    "    tf.summary.histogram(w.name, w)\n",
    "    \n",
    "total_loss = cross_entropy_loss + 7e-5 * l2_loss\n",
    "tf.summary.scalar('cross_entropy_loss', cross_entropy_loss)\n",
    "tf.summary.scalar('l2_loss', l2_loss)\n",
    "tf.summary.scalar('total_loss', total_loss)\n",
    "\n",
    "optimizer = tf.train.GradientDescentOptimizer(\n",
    "    learning_rate=0.3).minimize(total_loss)\n",
    "# optimizer = tf.train.AdagradOptimizerG(learning_rate=0.3).minimize(total_loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred = tf.nn.softmax(logits)\n",
    "correct_pred = tf.equal(tf.argmax(y, 1), tf.argmax(logits, 1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Mean_3:0' shape=() dtype=float32>"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义batch_size\n",
    "# 训练步骤\n",
    "# 训练模型存储\n",
    "batch_size = 100\n",
    "# trainig_step = 1100\n",
    "training_step = 4000\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after 100 training steps, the loss is 0.447501, the validation accuracy is 0.9068\n",
      "after 200 training steps, the loss is 0.380279, the validation accuracy is 0.9262\n",
      "after 300 training steps, the loss is 0.0667309, the validation accuracy is 0.9596\n",
      "after 400 training steps, the loss is 0.117999, the validation accuracy is 0.9698\n",
      "after 500 training steps, the loss is 0.195911, the validation accuracy is 0.9658\n",
      "after 600 training steps, the loss is 0.190387, the validation accuracy is 0.9734\n",
      "after 700 training steps, the loss is 0.13012, the validation accuracy is 0.9736\n",
      "after 800 training steps, the loss is 0.185219, the validation accuracy is 0.9724\n",
      "after 900 training steps, the loss is 0.0461256, the validation accuracy is 0.9768\n",
      "after 1000 training steps, the loss is 0.0654858, the validation accuracy is 0.9788\n",
      "the training is finish!\n",
      "the test accuarcy is: 0.9671\n"
     ]
    }
   ],
   "source": [
    "# summary.FileWriter\n",
    "#\n",
    "merged = tf.summary.merge_all()\n",
    "with tf.Session() as sess:\n",
    "\n",
    "    writer = tf.summary.FileWriter(\"logs/\", sess.graph)\n",
    "\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "\n",
    "    #定义验证集与测试集\n",
    "    validate_data = {\n",
    "        x: mnist.validation.images,\n",
    "        y: mnist.validation.labels,\n",
    "        keep_prob: 1.0\n",
    "    }\n",
    "    test_data = {x: mnist.test.images, y: mnist.test.labels, keep_prob: 1.0}\n",
    "\n",
    "    for i in range(trainig_step):\n",
    "        xs, ys = mnist.train.next_batch(batch_size)\n",
    "        _, loss, rs = sess.run(\n",
    "            [optimizer, cross_entropy_loss, merged],\n",
    "            feed_dict={\n",
    "                x: xs,\n",
    "                y: ys,\n",
    "                keep_prob: 0.6\n",
    "            })\n",
    "        writer.add_summary(rs, i)\n",
    "\n",
    "        #每100次训练打印一次损失值与验证准确率\n",
    "        if i > 0 and i % 100 == 0:\n",
    "            validate_accuracy = sess.run(accuracy, feed_dict=validate_data)\n",
    "            print(\n",
    "                \"after %d training steps, the loss is %g, the validation accuracy is %g\"\n",
    "                % (i, loss, validate_accuracy))\n",
    "            saver.save(sess, './model.ckpt', global_step=i)\n",
    "\n",
    "    print(\"the training is finish!\")\n",
    "    #最终的测试准确率\n",
    "    acc = sess.run(accuracy, feed_dict=test_data)\n",
    "    print(\"the test accuarcy is:\", acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from ./model.ckpt-1000\n",
      "1.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    ckpt = tf.train.get_checkpoint_state('./')\n",
    "    if ckpt and ckpt.model_checkpoint_path:\n",
    "        saver.restore(sess, ckpt.model_checkpoint_path)\n",
    "        final_pred, acc = sess.run(\n",
    "            [pred, accuracy],\n",
    "            feed_dict={\n",
    "                x: mnist.test.images[:16],\n",
    "                y: mnist.test.labels[:16],\n",
    "                keep_prob: 1.0\n",
    "            })\n",
    "        orders = np.argsort(final_pred)\n",
    "        plt.figure(figsize=(8, 8))\n",
    "        print(acc)\n",
    "        for idx in range(16):\n",
    "            order = orders[idx, :][-1]\n",
    "            prob = final_pred[idx, :][order]\n",
    "            plt.subplot(4, 4, idx + 1)\n",
    "            plt.axis('off')\n",
    "            plt.title('{}: [{}]-[{:.1f}%]'.format(\n",
    "                np.argmax(mnist.test.labels[idx]), order, prob * 100))\n",
    "            plt.imshow(mnist.test.images[idx].reshape((28, 28)))\n",
    "\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 代码不作为评判标准，如果运行正确，则认为代码没有错误。 \n",
    "# - 没有明显报错的正常的log输出 60分。 \n",
    "# - 卷积的特性描述20分。 \n",
    "# - 为什么卷积的效果要比全连接网络好，给出至少2点理由，每点10分。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# - 没有明显报错的正常的log输出 60分"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 卷积的特性描述：\n",
    "1.局部相关性\n",
    "  相邻的像素结合起来表达一个特征，距离较远的像素影响较小\n",
    "  随着层数的增加，feature map里面的点映射到原图的感受野越来越大\n",
    "  不仅仅可以适用于图像，其他具有局部相关性的数据均可以尝试卷积网络处理\n",
    "  带来一定的遮挡不变性\n",
    "2.参数共享\n",
    "3.平移宽容\n",
    "  在任何位置都可以激活神经元\n",
    "4.缩放宽容\n",
    "  一定程度内的图像缩放(通常认为25%以内)不会产生太大干扰\n",
    "5.少许降维 \n",
    "  例如:10x10的图像，用5x5的卷积核，采用valid方式(padding=0)，stride=2 输出feature map为: floor((10 – 5 + 0*2)/2) + 1 = 3 x 3 \n",
    "6.对输入的尺寸不做要求\n",
    "  全连接里面，权重W的尺寸是由输入决定的。\n",
    "  卷积核的尺寸只与网络设计有关，与输入没有任何关系\n",
    "  卷积核固定的情况下，feature的尺寸是随着输入变化的。            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 为什么卷积的效果要比全连接网络好，给出至少2点理由，每点10分。\n",
    "# 1.参数共享-计算时间复杂度降低\n",
    "# 2.对输入的尺寸不做要求\n",
    "#   全连接里面，权重W的尺寸是由输入决定的。\n",
    "#   卷积核的尺寸只与网络设计有关，与输入没有任何关系。  \n",
    "#   卷积核固定的情况下，feature的尺寸是随着输入变化的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
